package de.thwildau.tm.moses.asn1.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import de.thwildau.tm.moses.asn1.asn1.AlternativeTypeList;
import de.thwildau.tm.moses.asn1.asn1.AnyDefinedNamedType;
import de.thwildau.tm.moses.asn1.asn1.Asn1;
import de.thwildau.tm.moses.asn1.asn1.Asn1Package;
import de.thwildau.tm.moses.asn1.asn1.BMPString;
import de.thwildau.tm.moses.asn1.asn1.BitStringType;
import de.thwildau.tm.moses.asn1.asn1.BitStringValue;
import de.thwildau.tm.moses.asn1.asn1.BooleanType;
import de.thwildau.tm.moses.asn1.asn1.BooleanValue;
import de.thwildau.tm.moses.asn1.asn1.CString;
import de.thwildau.tm.moses.asn1.asn1.ChoiceType;
import de.thwildau.tm.moses.asn1.asn1.ChoiceValue;
import de.thwildau.tm.moses.asn1.asn1.ChoiceValueAssignment;
import de.thwildau.tm.moses.asn1.asn1.ClassNumber;
import de.thwildau.tm.moses.asn1.asn1.ComponentOfType;
import de.thwildau.tm.moses.asn1.asn1.ComponentTypeList;
import de.thwildau.tm.moses.asn1.asn1.ComponentValueList;
import de.thwildau.tm.moses.asn1.asn1.Constraint;
import de.thwildau.tm.moses.asn1.asn1.ContainedSubtype;
import de.thwildau.tm.moses.asn1.asn1.DateTimeType;
import de.thwildau.tm.moses.asn1.asn1.DateType;
import de.thwildau.tm.moses.asn1.asn1.DefinedType;
import de.thwildau.tm.moses.asn1.asn1.DefinedValue;
import de.thwildau.tm.moses.asn1.asn1.DurationType;
import de.thwildau.tm.moses.asn1.asn1.ElementSetSpec;
import de.thwildau.tm.moses.asn1.asn1.ElementSetSpecs;
import de.thwildau.tm.moses.asn1.asn1.EncodingReferenceDefault;
import de.thwildau.tm.moses.asn1.asn1.EnumeratedType;
import de.thwildau.tm.moses.asn1.asn1.EnumerationItem;
import de.thwildau.tm.moses.asn1.asn1.ExceptionIdentification;
import de.thwildau.tm.moses.asn1.asn1.ExceptionSpec;
import de.thwildau.tm.moses.asn1.asn1.Exclusions;
import de.thwildau.tm.moses.asn1.asn1.Exports;
import de.thwildau.tm.moses.asn1.asn1.ExtensionAdditionAlternativesGroup;
import de.thwildau.tm.moses.asn1.asn1.ExtensionAdditionAlternativesList;
import de.thwildau.tm.moses.asn1.asn1.ExtensionAdditionGroup;
import de.thwildau.tm.moses.asn1.asn1.ExtensionAdditions;
import de.thwildau.tm.moses.asn1.asn1.ExtensionAndException;
import de.thwildau.tm.moses.asn1.asn1.GeneralString;
import de.thwildau.tm.moses.asn1.asn1.GraphicString;
import de.thwildau.tm.moses.asn1.asn1.IA5String;
import de.thwildau.tm.moses.asn1.asn1.ISO646String;
import de.thwildau.tm.moses.asn1.asn1.Imports;
import de.thwildau.tm.moses.asn1.asn1.IntegerType;
import de.thwildau.tm.moses.asn1.asn1.IntegerValue;
import de.thwildau.tm.moses.asn1.asn1.IntersectionElements;
import de.thwildau.tm.moses.asn1.asn1.Intersections;
import de.thwildau.tm.moses.asn1.asn1.LowerEndValue;
import de.thwildau.tm.moses.asn1.asn1.LowerEndpoint;
import de.thwildau.tm.moses.asn1.asn1.ModuleBody;
import de.thwildau.tm.moses.asn1.asn1.ModuleDefinition;
import de.thwildau.tm.moses.asn1.asn1.ModuleIdentifier;
import de.thwildau.tm.moses.asn1.asn1.NamedBit;
import de.thwildau.tm.moses.asn1.asn1.NamedComponentType;
import de.thwildau.tm.moses.asn1.asn1.NamedNumber;
import de.thwildau.tm.moses.asn1.asn1.NamedType;
import de.thwildau.tm.moses.asn1.asn1.NamedValue;
import de.thwildau.tm.moses.asn1.asn1.NullType;
import de.thwildau.tm.moses.asn1.asn1.NullValue;
import de.thwildau.tm.moses.asn1.asn1.NumericRealValue;
import de.thwildau.tm.moses.asn1.asn1.NumericString;
import de.thwildau.tm.moses.asn1.asn1.ObjIdComponents;
import de.thwildau.tm.moses.asn1.asn1.ObjectIdentifierType;
import de.thwildau.tm.moses.asn1.asn1.ObjectIdentifierValue;
import de.thwildau.tm.moses.asn1.asn1.ObjectIdentifierValueAssignment;
import de.thwildau.tm.moses.asn1.asn1.OctetStringType;
import de.thwildau.tm.moses.asn1.asn1.OctetStringValue;
import de.thwildau.tm.moses.asn1.asn1.PermittedAlphabet;
import de.thwildau.tm.moses.asn1.asn1.PrintableString;
import de.thwildau.tm.moses.asn1.asn1.RealSequenceValue;
import de.thwildau.tm.moses.asn1.asn1.RealType;
import de.thwildau.tm.moses.asn1.asn1.SequenceOfType;
import de.thwildau.tm.moses.asn1.asn1.SequenceType;
import de.thwildau.tm.moses.asn1.asn1.SequenceValue;
import de.thwildau.tm.moses.asn1.asn1.SequenceValueAssignment;
import de.thwildau.tm.moses.asn1.asn1.SetOfType;
import de.thwildau.tm.moses.asn1.asn1.SetType;
import de.thwildau.tm.moses.asn1.asn1.SimpleValueAssignment;
import de.thwildau.tm.moses.asn1.asn1.SingleValue;
import de.thwildau.tm.moses.asn1.asn1.SizeConstraint;
import de.thwildau.tm.moses.asn1.asn1.SpecialRealValue;
import de.thwildau.tm.moses.asn1.asn1.T61String;
import de.thwildau.tm.moses.asn1.asn1.Tag;
import de.thwildau.tm.moses.asn1.asn1.TaggedType;
import de.thwildau.tm.moses.asn1.asn1.TeletexString;
import de.thwildau.tm.moses.asn1.asn1.TimeOfDayType;
import de.thwildau.tm.moses.asn1.asn1.TimeType;
import de.thwildau.tm.moses.asn1.asn1.TypeAssignment;
import de.thwildau.tm.moses.asn1.asn1.TypeConstraint;
import de.thwildau.tm.moses.asn1.asn1.UTF8String;
import de.thwildau.tm.moses.asn1.asn1.Unions;
import de.thwildau.tm.moses.asn1.asn1.UniversalString;
import de.thwildau.tm.moses.asn1.asn1.UnrestrictedCharacterStringType;
import de.thwildau.tm.moses.asn1.asn1.UpperEndValue;
import de.thwildau.tm.moses.asn1.asn1.UpperEndpoint;
import de.thwildau.tm.moses.asn1.asn1.UsefulType;
import de.thwildau.tm.moses.asn1.asn1.ValueRange;
import de.thwildau.tm.moses.asn1.asn1.VersionNumber;
import de.thwildau.tm.moses.asn1.asn1.VideotexString;
import de.thwildau.tm.moses.asn1.asn1.VisibleString;
import de.thwildau.tm.moses.asn1.services.Asn1GrammarAccess;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class Asn1SemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private Asn1GrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == Asn1Package.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case Asn1Package.ALTERNATIVE_TYPE_LIST:
				if(context == grammarAccess.getAlternativeTypeListRule()) {
					sequence_AlternativeTypeList(context, (AlternativeTypeList) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ANY_DEFINED_NAMED_TYPE:
				if(context == grammarAccess.getAnyDefinedNamedTypeRule() ||
				   context == grammarAccess.getComponentTypeRule() ||
				   context == grammarAccess.getExtensionAdditionRule()) {
					sequence_AnyDefinedNamedType(context, (AnyDefinedNamedType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ASN1:
				if(context == grammarAccess.getAsn1Rule()) {
					sequence_Asn1(context, (Asn1) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.BMP_STRING:
				if(context == grammarAccess.getBMPStringRule() ||
				   context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_BMPString(context, (BMPString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.BIT_STRING_TYPE:
				if(context == grammarAccess.getBitStringTypeRule() ||
				   context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_BitStringType(context, (BitStringType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.BIT_STRING_VALUE:
				if(context == grammarAccess.getBitStringValueRule()) {
					sequence_BitStringValue(context, (BitStringValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.BOOLEAN_TYPE:
				if(context == grammarAccess.getBooleanTypeRule() ||
				   context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_BooleanType(context, (BooleanType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.BOOLEAN_VALUE:
				if(context == grammarAccess.getBooleanValueRule() ||
				   context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getValueRule()) {
					sequence_BooleanValue(context, (BooleanValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CSTRING:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getCharacterStringValueRule() ||
				   context == grammarAccess.getRestrictedCharacterStringValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getValueRule() ||
				   context == grammarAccess.getValueRangeValueRule()) {
					sequence_RestrictedCharacterStringValue(context, (CString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CHOICE_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getChoiceTypeRule() ||
				   context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_ChoiceType(context, (ChoiceType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CHOICE_VALUE:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getChoiceValueRule() ||
				   context == grammarAccess.getContainerValueRule() ||
				   context == grammarAccess.getValueRule()) {
					sequence_ChoiceValue(context, (ChoiceValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CHOICE_VALUE_ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule() ||
				   context == grammarAccess.getChoiceValueAssignmentRule() ||
				   context == grammarAccess.getValueAssignmentRule()) {
					sequence_ChoiceValueAssignment(context, (ChoiceValueAssignment) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CLASS_NUMBER:
				if(context == grammarAccess.getClassNumberRule()) {
					sequence_ClassNumber(context, (ClassNumber) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.COMPONENT_OF_TYPE:
				if(context == grammarAccess.getComponentOfTypeRule() ||
				   context == grammarAccess.getComponentTypeRule() ||
				   context == grammarAccess.getExtensionAdditionRule()) {
					sequence_ComponentOfType(context, (ComponentOfType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.COMPONENT_TYPE_LIST:
				if(context == grammarAccess.getComponentTypeListRule()) {
					sequence_ComponentTypeList(context, (ComponentTypeList) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.COMPONENT_VALUE_LIST:
				if(context == grammarAccess.getComponentValueListRule()) {
					sequence_ComponentValueList(context, (ComponentValueList) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CONSTRAINT:
				if(context == grammarAccess.getConstraintRule()) {
					sequence_Constraint(context, (Constraint) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.CONTAINED_SUBTYPE:
				if(context == grammarAccess.getContainedSubtypeRule() ||
				   context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getSubtypeElementsRule()) {
					sequence_ContainedSubtype(context, (ContainedSubtype) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.DATE_TIME_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getDateTimeTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_DateTimeType(context, (DateTimeType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.DATE_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getDateTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_DateType(context, (DateType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.DEFINED_TYPE:
				if(context == grammarAccess.getDefinedTypeRule() ||
				   context == grammarAccess.getReferencedTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_DefinedType(context, (DefinedType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.DEFINED_VALUE:
				if(context == grammarAccess.getDefinedValueRule() ||
				   context == grammarAccess.getObjIdComponentsRule() ||
				   context == grammarAccess.getReferencedValueRule() ||
				   context == grammarAccess.getValueRule()) {
					sequence_DefinedValue(context, (DefinedValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.DURATION_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getDurationTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_DurationType(context, (DurationType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ELEMENT_SET_SPEC:
				if(context == grammarAccess.getElementSetSpecRule()) {
					sequence_ElementSetSpec(context, (ElementSetSpec) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ELEMENT_SET_SPECS:
				if(context == grammarAccess.getConstraintSpecRule() ||
				   context == grammarAccess.getElementSetSpecsRule() ||
				   context == grammarAccess.getSubtypeConstraintRule()) {
					sequence_ElementSetSpecs(context, (ElementSetSpecs) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ENCODING_REFERENCE_DEFAULT:
				if(context == grammarAccess.getEncodingReferenceDefaultRule()) {
					sequence_EncodingReferenceDefault(context, (EncodingReferenceDefault) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ENUMERATED_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getEnumeratedTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_EnumeratedType(context, (EnumeratedType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ENUMERATION_ITEM:
				if(context == grammarAccess.getEnumerationItemRule()) {
					sequence_EnumerationItem(context, (EnumerationItem) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXCEPTION_IDENTIFICATION:
				if(context == grammarAccess.getExceptionIdentificationRule()) {
					sequence_ExceptionIdentification(context, (ExceptionIdentification) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXCEPTION_SPEC:
				if(context == grammarAccess.getExceptionSpecRule()) {
					sequence_ExceptionSpec(context, (ExceptionSpec) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXCLUSIONS:
				if(context == grammarAccess.getExclusionsRule()) {
					sequence_Exclusions(context, (Exclusions) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXPORTS:
				if(context == grammarAccess.getExportsRule()) {
					sequence_Exports(context, (Exports) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXTENSION_ADDITION_ALTERNATIVES_GROUP:
				if(context == grammarAccess.getExtensionAdditionAlternativeRule() ||
				   context == grammarAccess.getExtensionAdditionAlternativesGroupRule()) {
					sequence_ExtensionAdditionAlternativesGroup(context, (ExtensionAdditionAlternativesGroup) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXTENSION_ADDITION_ALTERNATIVES_LIST:
				if(context == grammarAccess.getExtensionAdditionAlternativesListRule()) {
					sequence_ExtensionAdditionAlternativesList(context, (ExtensionAdditionAlternativesList) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXTENSION_ADDITION_GROUP:
				if(context == grammarAccess.getExtensionAdditionRule() ||
				   context == grammarAccess.getExtensionAdditionGroupRule()) {
					sequence_ExtensionAdditionGroup(context, (ExtensionAdditionGroup) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXTENSION_ADDITIONS:
				if(context == grammarAccess.getExtensionAdditionsRule()) {
					sequence_ExtensionAdditions(context, (ExtensionAdditions) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.EXTENSION_AND_EXCEPTION:
				if(context == grammarAccess.getExtensionAndExceptionRule()) {
					sequence_ExtensionAndException(context, (ExtensionAndException) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.GENERAL_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getGeneralStringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_GeneralString(context, (GeneralString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.GRAPHIC_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getGraphicStringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_GraphicString(context, (GraphicString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.IA5_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getIA5StringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_IA5String(context, (IA5String) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.ISO646_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getISO646StringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_ISO646String(context, (ISO646String) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.IMPORTS:
				if(context == grammarAccess.getImportsRule()) {
					sequence_Imports(context, (Imports) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.INTEGER_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getIntegerTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_IntegerType(context, (IntegerType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.INTEGER_VALUE:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getIntegerValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getValueRule() ||
				   context == grammarAccess.getValueRangeValueRule()) {
					sequence_IntegerValue(context, (IntegerValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.INTERSECTION_ELEMENTS:
				if(context == grammarAccess.getIntersectionElementsRule()) {
					sequence_IntersectionElements(context, (IntersectionElements) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.INTERSECTIONS:
				if(context == grammarAccess.getIntersectionsRule()) {
					sequence_Intersections(context, (Intersections) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.LOWER_END_VALUE:
				if(context == grammarAccess.getLowerEndValueRule()) {
					sequence_LowerEndValue(context, (LowerEndValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.LOWER_ENDPOINT:
				if(context == grammarAccess.getLowerEndpointRule()) {
					sequence_LowerEndpoint(context, (LowerEndpoint) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.MODULE_BODY:
				if(context == grammarAccess.getModuleBodyRule()) {
					sequence_ModuleBody(context, (ModuleBody) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.MODULE_DEFINITION:
				if(context == grammarAccess.getModuleDefinitionRule()) {
					sequence_ModuleDefinition(context, (ModuleDefinition) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.MODULE_IDENTIFIER:
				if(context == grammarAccess.getModuleIdentifierRule()) {
					sequence_ModuleIdentifier(context, (ModuleIdentifier) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NAMED_BIT:
				if(context == grammarAccess.getNamedBitRule()) {
					sequence_NamedBit(context, (NamedBit) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NAMED_COMPONENT_TYPE:
				if(context == grammarAccess.getComponentTypeRule() ||
				   context == grammarAccess.getExtensionAdditionRule() ||
				   context == grammarAccess.getNamedComponentTypeRule()) {
					sequence_NamedComponentType(context, (NamedComponentType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NAMED_NUMBER:
				if(context == grammarAccess.getNamedNumberRule() ||
				   context == grammarAccess.getObjIdComponentsRule()) {
					sequence_NamedNumber(context, (NamedNumber) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NAMED_TYPE:
				if(context == grammarAccess.getExtensionAdditionAlternativeRule() ||
				   context == grammarAccess.getNamedTypeRule()) {
					sequence_NamedType(context, (NamedType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NAMED_VALUE:
				if(context == grammarAccess.getNamedValueRule()) {
					sequence_NamedValue(context, (NamedValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NULL_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getNullTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_NullType(context, (NullType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NULL_VALUE:
				if(context == grammarAccess.getNullValueRule()) {
					sequence_NullValue(context, (NullValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NUMERIC_REAL_VALUE:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getNumericRealValueRule() ||
				   context == grammarAccess.getRealValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getValueRule() ||
				   context == grammarAccess.getValueRangeValueRule()) {
					sequence_NumericRealValue(context, (NumericRealValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.NUMERIC_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getNumericStringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_NumericString(context, (NumericString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OBJ_ID_COMPONENTS:
				if(context == grammarAccess.getObjIdComponentsRule()) {
					sequence_ObjIdComponents(context, (ObjIdComponents) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OBJECT_IDENTIFIER_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getObjectIdentifierTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_ObjectIdentifierType(context, (ObjectIdentifierType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OBJECT_IDENTIFIER_VALUE:
				if(context == grammarAccess.getObjectIdentifierValueRule()) {
					sequence_ObjectIdentifierValue(context, (ObjectIdentifierValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OBJECT_IDENTIFIER_VALUE_ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule() ||
				   context == grammarAccess.getObjectIdentifierValueAssignmentRule() ||
				   context == grammarAccess.getValueAssignmentRule()) {
					sequence_ObjectIdentifierValueAssignment(context, (ObjectIdentifierValueAssignment) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OCTET_STRING_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getOctetStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_OctetStringType(context, (OctetStringType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.OCTET_STRING_VALUE:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getOctetStringValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getValueRule()) {
					sequence_OctetStringValue(context, (OctetStringValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.PERMITTED_ALPHABET:
				if(context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getPermittedAlphabetRule() ||
				   context == grammarAccess.getSubtypeElementsRule()) {
					sequence_PermittedAlphabet(context, (PermittedAlphabet) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.PRINTABLE_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getPrintableStringRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_PrintableString(context, (PrintableString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.REAL_SEQUENCE_VALUE:
				if(context == grammarAccess.getRealSequenceValueRule()) {
					sequence_RealSequenceValue(context, (RealSequenceValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.REAL_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getRealTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_RealType(context, (RealType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SEQUENCE_OF_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getSequenceOfTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_SequenceOfType(context, (SequenceOfType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SEQUENCE_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getSequenceTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_SequenceType(context, (SequenceType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SEQUENCE_VALUE:
				if(context == grammarAccess.getSequenceValueRule()) {
					sequence_SequenceValue(context, (SequenceValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SEQUENCE_VALUE_ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule() ||
				   context == grammarAccess.getSequenceValueAssignmentRule() ||
				   context == grammarAccess.getValueAssignmentRule()) {
					sequence_SequenceValueAssignment(context, (SequenceValueAssignment) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SET_OF_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getSetOfTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_SetOfType(context, (SetOfType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SET_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getContainerTypeRule() ||
				   context == grammarAccess.getSetTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_SetType(context, (SetType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SIMPLE_VALUE_ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule() ||
				   context == grammarAccess.getSimpleValueAssignmentRule() ||
				   context == grammarAccess.getValueAssignmentRule()) {
					sequence_SimpleValueAssignment(context, (SimpleValueAssignment) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SINGLE_VALUE:
				if(context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getSingleValueRule() ||
				   context == grammarAccess.getSubtypeElementsRule()) {
					sequence_SingleValue(context, (SingleValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SIZE_CONSTRAINT:
				if(context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getSizeConstraintRule() ||
				   context == grammarAccess.getSubtypeElementsRule()) {
					sequence_SizeConstraint(context, (SizeConstraint) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.SPECIAL_REAL_VALUE:
				if(context == grammarAccess.getBuiltinValueRule() ||
				   context == grammarAccess.getRealValueRule() ||
				   context == grammarAccess.getSimpleValueRule() ||
				   context == grammarAccess.getSpecialRealValueRule() ||
				   context == grammarAccess.getValueRule() ||
				   context == grammarAccess.getValueRangeValueRule()) {
					sequence_SpecialRealValue(context, (SpecialRealValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.T61_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getT61StringRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_T61String(context, (T61String) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TAG:
				if(context == grammarAccess.getTagRule()) {
					sequence_Tag(context, (Tag) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TAGGED_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getPrefixedTypeRule() ||
				   context == grammarAccess.getTaggedTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_TaggedType(context, (TaggedType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TELETEX_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTeletexStringRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_TeletexString(context, (TeletexString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TIME_OF_DAY_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTimeOfDayTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_TimeOfDayType(context, (TimeOfDayType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TIME_TYPE:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTimeTypeRule() ||
				   context == grammarAccess.getTypeRule()) {
					sequence_TimeType(context, (TimeType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TYPE_ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule() ||
				   context == grammarAccess.getTypeAssignmentRule()) {
					sequence_TypeAssignment(context, (TypeAssignment) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.TYPE_CONSTRAINT:
				if(context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getSubtypeElementsRule() ||
				   context == grammarAccess.getTypeConstraintRule()) {
					sequence_TypeConstraint(context, (TypeConstraint) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UTF8_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUTF8StringRule()) {
					sequence_UTF8String(context, (UTF8String) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UNIONS:
				if(context == grammarAccess.getElementSetSpecRule() ||
				   context == grammarAccess.getUnionsRule()) {
					sequence_Unions(context, (Unions) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UNIVERSAL_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUniversalStringRule()) {
					sequence_UniversalString(context, (UniversalString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UNRESTRICTED_CHARACTER_STRING_TYPE:
				if(context == grammarAccess.getUnrestrictedCharacterStringTypeRule()) {
					sequence_UnrestrictedCharacterStringType(context, (UnrestrictedCharacterStringType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UPPER_END_VALUE:
				if(context == grammarAccess.getUpperEndValueRule()) {
					sequence_UpperEndValue(context, (UpperEndValue) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.UPPER_ENDPOINT:
				if(context == grammarAccess.getUpperEndpointRule()) {
					sequence_UpperEndpoint(context, (UpperEndpoint) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.USEFUL_TYPE:
				if(context == grammarAccess.getReferencedTypeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getUsefulTypeRule()) {
					sequence_UsefulType(context, (UsefulType) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.VALUE_RANGE:
				if(context == grammarAccess.getElementsRule() ||
				   context == grammarAccess.getSubtypeElementsRule() ||
				   context == grammarAccess.getValueRangeRule()) {
					sequence_ValueRange(context, (ValueRange) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.VERSION_NUMBER:
				if(context == grammarAccess.getVersionNumberRule()) {
					sequence_VersionNumber(context, (VersionNumber) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.VIDEOTEX_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getVideotexStringRule()) {
					sequence_VideotexString(context, (VideotexString) semanticObject); 
					return; 
				}
				else break;
			case Asn1Package.VISIBLE_STRING:
				if(context == grammarAccess.getBuiltinTypeRule() ||
				   context == grammarAccess.getCharacterStringTypeRule() ||
				   context == grammarAccess.getRestrictedCharacterStringTypeRule() ||
				   context == grammarAccess.getSimpleTypeRule() ||
				   context == grammarAccess.getTypeRule() ||
				   context == grammarAccess.getVisibleStringRule()) {
					sequence_VisibleString(context, (VisibleString) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (namedTypes+=NamedType namedTypes+=NamedType*)
	 */
	protected void sequence_AlternativeTypeList(EObject context, AlternativeTypeList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID definedType=[NamedType|ID])
	 */
	protected void sequence_AnyDefinedNamedType(EObject context, AnyDefinedNamedType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ANY_DEFINED_NAMED_TYPE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ANY_DEFINED_NAMED_TYPE__NAME));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ANY_DEFINED_NAMED_TYPE__DEFINED_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ANY_DEFINED_NAMED_TYPE__DEFINED_TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAnyDefinedNamedTypeAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getAnyDefinedNamedTypeAccess().getDefinedTypeNamedTypeIDTerminalRuleCall_4_0_1(), semanticObject.getDefinedType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     moduleDefinition+=ModuleDefinition+
	 */
	protected void sequence_Asn1(EObject context, Asn1 semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {BMPString}
	 */
	protected void sequence_BMPString(EObject context, BMPString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((namedBits+=NamedBit namedBits+=NamedBit*)?)
	 */
	protected void sequence_BitStringType(EObject context, BitStringType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (identifiers+=ID*)
	 */
	protected void sequence_BitStringValue(EObject context, BitStringValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {BooleanType}
	 */
	protected void sequence_BooleanType(EObject context, BooleanType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=BOOL
	 */
	protected void sequence_BooleanValue(EObject context, BooleanValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.BOOLEAN_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.BOOLEAN_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBooleanValueAccess().getValueBOOLEnumRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         alternativeTypeList=AlternativeTypeList 
	 *         (extensionAndException=ExtensionAndException extensionAdditionAlternativesList=ExtensionAdditionAlternativesList?)?
	 *     )
	 */
	protected void sequence_ChoiceType(EObject context, ChoiceType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=[TypeAssignment|ID] value=ChoiceValue)
	 */
	protected void sequence_ChoiceValueAssignment(EObject context, ChoiceValueAssignment semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.CHOICE_VALUE_ASSIGNMENT__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.CHOICE_VALUE_ASSIGNMENT__TYPE));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.CHOICE_VALUE_ASSIGNMENT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.CHOICE_VALUE_ASSIGNMENT__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getChoiceValueAssignmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getChoiceValueAssignmentAccess().getTypeTypeAssignmentIDTerminalRuleCall_1_0_1(), semanticObject.getType());
		feeder.accept(grammarAccess.getChoiceValueAssignmentAccess().getValueChoiceValueParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (identifier=ID value=Value)
	 */
	protected void sequence_ChoiceValue(EObject context, ChoiceValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.CHOICE_VALUE__IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.CHOICE_VALUE__IDENTIFIER));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.CHOICE_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.CHOICE_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getChoiceValueAccess().getIdentifierIDTerminalRuleCall_0_0(), semanticObject.getIdentifier());
		feeder.accept(grammarAccess.getChoiceValueAccess().getValueValueParserRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (number=LONG | value=DefinedValue)
	 */
	protected void sequence_ClassNumber(EObject context, ClassNumber semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     type=Type
	 */
	protected void sequence_ComponentOfType(EObject context, ComponentOfType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.COMPONENT_OF_TYPE__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.COMPONENT_OF_TYPE__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getComponentOfTypeAccess().getTypeTypeParserRuleCall_2_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (componentTypes+=ComponentType componentTypes+=ComponentType*)
	 */
	protected void sequence_ComponentTypeList(EObject context, ComponentTypeList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (values+=NamedValue values+=NamedValue*)
	 */
	protected void sequence_ComponentValueList(EObject context, ComponentValueList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (constraintSpec=ConstraintSpec exceptionSpec=ExceptionSpec?)
	 */
	protected void sequence_Constraint(EObject context, Constraint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     type=Type
	 */
	protected void sequence_ContainedSubtype(EObject context, ContainedSubtype semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.CONTAINED_SUBTYPE__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.CONTAINED_SUBTYPE__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getContainedSubtypeAccess().getTypeTypeParserRuleCall_1_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {DateTimeType}
	 */
	protected void sequence_DateTimeType(EObject context, DateTimeType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {DateType}
	 */
	protected void sequence_DateType(EObject context, DateType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     target=[TypeAssignment|ID]
	 */
	protected void sequence_DefinedType(EObject context, DefinedType semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.DEFINED_TYPE__TARGET) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.DEFINED_TYPE__TARGET));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDefinedTypeAccess().getTargetTypeAssignmentIDTerminalRuleCall_0_1(), semanticObject.getTarget());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     target=[ValueAssignment|ID]
	 */
	protected void sequence_DefinedValue(EObject context, DefinedValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {DurationType}
	 */
	protected void sequence_DurationType(EObject context, DurationType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     exclusions=Exclusions
	 */
	protected void sequence_ElementSetSpec(EObject context, ElementSetSpec semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ELEMENT_SET_SPEC__EXCLUSIONS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ELEMENT_SET_SPEC__EXCLUSIONS));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getElementSetSpecAccess().getExclusionsExclusionsParserRuleCall_1_1_0(), semanticObject.getExclusions());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (elementSetSpec+=ElementSetSpec elementSetSpec+=ElementSetSpec?)
	 */
	protected void sequence_ElementSetSpecs(EObject context, ElementSetSpecs semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_EncodingReferenceDefault(EObject context, EncodingReferenceDefault semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ENCODING_REFERENCE_DEFAULT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ENCODING_REFERENCE_DEFAULT__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getEncodingReferenceDefaultAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (exception=ExceptionSpec? enums+=EnumerationItem enums+=EnumerationItem*)
	 */
	protected void sequence_EnumeratedType(EObject context, EnumeratedType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID | number=NamedNumber | unspec='...')
	 */
	protected void sequence_EnumerationItem(EObject context, EnumerationItem semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (number=LONG | defValue=DefinedValue | (type=Type value=Value))
	 */
	protected void sequence_ExceptionIdentification(EObject context, ExceptionIdentification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     exception=ExceptionIdentification
	 */
	protected void sequence_ExceptionSpec(EObject context, ExceptionSpec semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXCEPTION_SPEC__EXCEPTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXCEPTION_SPEC__EXCEPTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getExceptionSpecAccess().getExceptionExceptionIdentificationParserRuleCall_0(), semanticObject.getException());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     elements=Elements
	 */
	protected void sequence_Exclusions(EObject context, Exclusions semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXCLUSIONS__ELEMENTS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXCLUSIONS__ELEMENTS));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getExclusionsAccess().getElementsElementsParserRuleCall_1_0(), semanticObject.getElements());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((symbolsExported+=[Assignment|ID] symbolsExported+=[Assignment|ID]*)?)
	 */
	protected void sequence_Exports(EObject context, Exports semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (versionNumber=VersionNumber alternativeTypeList=AlternativeTypeList)
	 */
	protected void sequence_ExtensionAdditionAlternativesGroup(EObject context, ExtensionAdditionAlternativesGroup semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_ALTERNATIVES_GROUP__VERSION_NUMBER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_ALTERNATIVES_GROUP__VERSION_NUMBER));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_ALTERNATIVES_GROUP__ALTERNATIVE_TYPE_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_ALTERNATIVES_GROUP__ALTERNATIVE_TYPE_LIST));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getExtensionAdditionAlternativesGroupAccess().getVersionNumberVersionNumberParserRuleCall_1_0(), semanticObject.getVersionNumber());
		feeder.accept(grammarAccess.getExtensionAdditionAlternativesGroupAccess().getAlternativeTypeListAlternativeTypeListParserRuleCall_2_0(), semanticObject.getAlternativeTypeList());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (extensionAdditionAlternative+=ExtensionAdditionAlternative extensionAdditionAlternative+=ExtensionAdditionAlternative*)
	 */
	protected void sequence_ExtensionAdditionAlternativesList(EObject context, ExtensionAdditionAlternativesList semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (versionNumber=VersionNumber componentTypeList=ComponentTypeList)
	 */
	protected void sequence_ExtensionAdditionGroup(EObject context, ExtensionAdditionGroup semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_GROUP__VERSION_NUMBER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_GROUP__VERSION_NUMBER));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_GROUP__COMPONENT_TYPE_LIST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.EXTENSION_ADDITION_GROUP__COMPONENT_TYPE_LIST));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getExtensionAdditionGroupAccess().getVersionNumberVersionNumberParserRuleCall_1_0(), semanticObject.getVersionNumber());
		feeder.accept(grammarAccess.getExtensionAdditionGroupAccess().getComponentTypeListComponentTypeListParserRuleCall_2_0(), semanticObject.getComponentTypeList());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (extensionAdditions+=ExtensionAddition extensionAdditions+=ExtensionAddition*)
	 */
	protected void sequence_ExtensionAdditions(EObject context, ExtensionAdditions semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (exception=ExceptionSpec?)
	 */
	protected void sequence_ExtensionAndException(EObject context, ExtensionAndException semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {GeneralString}
	 */
	protected void sequence_GeneralString(EObject context, GeneralString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {GraphicString}
	 */
	protected void sequence_GraphicString(EObject context, GraphicString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {IA5String}
	 */
	protected void sequence_IA5String(EObject context, IA5String semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {ISO646String}
	 */
	protected void sequence_ISO646String(EObject context, ISO646String semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolsImported+=[Assignment|ID] symbolsImported+=[Assignment|ID]* modulereference=ID)
	 */
	protected void sequence_Imports(EObject context, Imports semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((namedNumberList+=NamedNumber namedNumberList+=NamedNumber*)?)
	 */
	protected void sequence_IntegerType(EObject context, IntegerType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=SignedNumber
	 */
	protected void sequence_IntegerValue(EObject context, IntegerValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.INTEGER_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.INTEGER_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getIntegerValueAccess().getValueSignedNumberParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (elements=Elements exclusions=Exclusions?)
	 */
	protected void sequence_IntersectionElements(EObject context, IntersectionElements semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (intersectionElements+=IntersectionElements intersectionElements+=IntersectionElements*)
	 */
	protected void sequence_Intersections(EObject context, Intersections semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (value=ValueRangeValue | minValue='MIN')
	 */
	protected void sequence_LowerEndValue(EObject context, LowerEndValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (value=LowerEndValue closed='<'?)
	 */
	protected void sequence_LowerEndpoint(EObject context, LowerEndpoint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (exports+=Exports* imports+=Imports* assignments+=Assignment+)
	 */
	protected void sequence_ModuleBody(EObject context, ModuleBody semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         moduleIdentifier=ModuleIdentifier 
	 *         encodingReferenceDefault=EncodingReferenceDefault? 
	 *         tagDefault=TagDefault? 
	 *         extensionDefault=ExtensionDefault? 
	 *         moduleBody=ModuleBody?
	 *     )
	 */
	protected void sequence_ModuleDefinition(EObject context, ModuleDefinition semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     moduleReference=ID
	 */
	protected void sequence_ModuleIdentifier(EObject context, ModuleIdentifier semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.MODULE_IDENTIFIER__MODULE_REFERENCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.MODULE_IDENTIFIER__MODULE_REFERENCE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getModuleIdentifierAccess().getModuleReferenceIDTerminalRuleCall_0(), semanticObject.getModuleReference());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((identifier=ID number=LONG) | (identifier=ID value=DefinedValue))
	 */
	protected void sequence_NamedBit(EObject context, NamedBit semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (namedType=NamedType value=Value?)
	 */
	protected void sequence_NamedComponentType(EObject context, NamedComponentType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((name=ID number=SignedNumber) | (name=ID value=DefinedValue))
	 */
	protected void sequence_NamedNumber(EObject context, NamedNumber semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=Type constraint=Constraint?)
	 */
	protected void sequence_NamedType(EObject context, NamedType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (identifier=ID value=Value)
	 */
	protected void sequence_NamedValue(EObject context, NamedValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.NAMED_VALUE__IDENTIFIER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.NAMED_VALUE__IDENTIFIER));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.NAMED_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.NAMED_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getNamedValueAccess().getIdentifierIDTerminalRuleCall_0_0(), semanticObject.getIdentifier());
		feeder.accept(grammarAccess.getNamedValueAccess().getValueValueParserRuleCall_1_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {NullType}
	 */
	protected void sequence_NullType(EObject context, NullType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value='NULL'
	 */
	protected void sequence_NullValue(EObject context, NullValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.NULL_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.NULL_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getNullValueAccess().getValueNULLKeyword_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (value=DoubleNumber | sequenceValue=RealSequenceValue)
	 */
	protected void sequence_NumericRealValue(EObject context, NumericRealValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {NumericString}
	 */
	protected void sequence_NumericString(EObject context, NumericString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     number=LONG
	 */
	protected void sequence_ObjIdComponents(EObject context, ObjIdComponents semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.OBJ_ID_COMPONENTS__NUMBER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.OBJ_ID_COMPONENTS__NUMBER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getObjIdComponentsAccess().getNumberLONGTerminalRuleCall_0_0(), semanticObject.getNumber());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {ObjectIdentifierType}
	 */
	protected void sequence_ObjectIdentifierType(EObject context, ObjectIdentifierType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=ObjectIdentifierType value=ObjectIdentifierValue)
	 */
	protected void sequence_ObjectIdentifierValueAssignment(EObject context, ObjectIdentifierValueAssignment semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.OBJECT_IDENTIFIER_VALUE_ASSIGNMENT__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.OBJECT_IDENTIFIER_VALUE_ASSIGNMENT__TYPE));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.OBJECT_IDENTIFIER_VALUE_ASSIGNMENT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.OBJECT_IDENTIFIER_VALUE_ASSIGNMENT__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getObjectIdentifierValueAssignmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getObjectIdentifierValueAssignmentAccess().getTypeObjectIdentifierTypeParserRuleCall_1_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getObjectIdentifierValueAssignmentAccess().getValueObjectIdentifierValueParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     components+=ObjIdComponents+
	 */
	protected void sequence_ObjectIdentifierValue(EObject context, ObjectIdentifierValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {OctetStringType}
	 */
	protected void sequence_OctetStringType(EObject context, OctetStringType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (binString=B_STRING | hexString=H_STRING | acontainingValue=Value)
	 */
	protected void sequence_OctetStringValue(EObject context, OctetStringValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     constraint=Constraint
	 */
	protected void sequence_PermittedAlphabet(EObject context, PermittedAlphabet semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.PERMITTED_ALPHABET__CONSTRAINT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.PERMITTED_ALPHABET__CONSTRAINT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getPermittedAlphabetAccess().getConstraintConstraintParserRuleCall_1_0(), semanticObject.getConstraint());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {PrintableString}
	 */
	protected void sequence_PrintableString(EObject context, PrintableString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (mantissa=SignedNumber base=SignedNumber exponent=SignedNumber)
	 */
	protected void sequence_RealSequenceValue(EObject context, RealSequenceValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__MANTISSA) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__MANTISSA));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__BASE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__BASE));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__EXPONENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.REAL_SEQUENCE_VALUE__EXPONENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRealSequenceValueAccess().getMantissaSignedNumberParserRuleCall_2_0(), semanticObject.getMantissa());
		feeder.accept(grammarAccess.getRealSequenceValueAccess().getBaseSignedNumberParserRuleCall_5_0(), semanticObject.getBase());
		feeder.accept(grammarAccess.getRealSequenceValueAccess().getExponentSignedNumberParserRuleCall_8_0(), semanticObject.getExponent());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {RealType}
	 */
	protected void sequence_RealType(EObject context, RealType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {CString}
	 */
	protected void sequence_RestrictedCharacterStringValue(EObject context, CString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (constraint=Constraint? type=Type)
	 */
	protected void sequence_SequenceOfType(EObject context, SequenceOfType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (componentTypeList=ComponentTypeList? (extensionAndException=ExtensionAndException extensionAdditions=ExtensionAdditions?)?)
	 */
	protected void sequence_SequenceType(EObject context, SequenceType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=[TypeAssignment|ID] value=SequenceValue)
	 */
	protected void sequence_SequenceValueAssignment(EObject context, SequenceValueAssignment semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SEQUENCE_VALUE_ASSIGNMENT__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SEQUENCE_VALUE_ASSIGNMENT__TYPE));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SEQUENCE_VALUE_ASSIGNMENT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SEQUENCE_VALUE_ASSIGNMENT__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSequenceValueAssignmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getSequenceValueAssignmentAccess().getTypeTypeAssignmentIDTerminalRuleCall_1_0_1(), semanticObject.getType());
		feeder.accept(grammarAccess.getSequenceValueAssignmentAccess().getValueSequenceValueParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (componentValueList=ComponentValueList?)
	 */
	protected void sequence_SequenceValue(EObject context, SequenceValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (constraint=Constraint? type=Type)
	 */
	protected void sequence_SetOfType(EObject context, SetOfType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((extensionAndException=ExtensionAndException | componentTypeList=ComponentTypeList)?)
	 */
	protected void sequence_SetType(EObject context, SetType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=SimpleType value=SimpleValue)
	 */
	protected void sequence_SimpleValueAssignment(EObject context, SimpleValueAssignment semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.ASSIGNMENT__NAME));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SIMPLE_VALUE_ASSIGNMENT__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SIMPLE_VALUE_ASSIGNMENT__TYPE));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SIMPLE_VALUE_ASSIGNMENT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SIMPLE_VALUE_ASSIGNMENT__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSimpleValueAssignmentAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getSimpleValueAssignmentAccess().getTypeSimpleTypeParserRuleCall_1_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getSimpleValueAssignmentAccess().getValueSimpleValueParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     value=Value
	 */
	protected void sequence_SingleValue(EObject context, SingleValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SINGLE_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SINGLE_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSingleValueAccess().getValueValueParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     constraint=Constraint
	 */
	protected void sequence_SizeConstraint(EObject context, SizeConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SIZE_CONSTRAINT__CONSTRAINT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SIZE_CONSTRAINT__CONSTRAINT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSizeConstraintAccess().getConstraintConstraintParserRuleCall_1_0(), semanticObject.getConstraint());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     value=SpecialValue
	 */
	protected void sequence_SpecialRealValue(EObject context, SpecialRealValue semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.SPECIAL_REAL_VALUE__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.SPECIAL_REAL_VALUE__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSpecialRealValueAccess().getValueSpecialValueEnumRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {T61String}
	 */
	protected void sequence_T61String(EObject context, T61String semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (encodingReference=ID? tagClass=TagClass? classNumber=ClassNumber)
	 */
	protected void sequence_Tag(EObject context, Tag semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (tag=Tag tagSpec=TagSpec? type=Type)
	 */
	protected void sequence_TaggedType(EObject context, TaggedType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {TeletexString}
	 */
	protected void sequence_TeletexString(EObject context, TeletexString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {TimeOfDayType}
	 */
	protected void sequence_TimeOfDayType(EObject context, TimeOfDayType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {TimeType}
	 */
	protected void sequence_TimeType(EObject context, TimeType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID type=Type constraint=Constraint?)
	 */
	protected void sequence_TypeAssignment(EObject context, TypeAssignment semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     type=Type
	 */
	protected void sequence_TypeConstraint(EObject context, TypeConstraint semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.TYPE_CONSTRAINT__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.TYPE_CONSTRAINT__TYPE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getTypeConstraintAccess().getTypeTypeParserRuleCall_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {UTF8String}
	 */
	protected void sequence_UTF8String(EObject context, UTF8String semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (intersections+=Intersections intersections+=Intersections*)
	 */
	protected void sequence_Unions(EObject context, Unions semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {UniversalString}
	 */
	protected void sequence_UniversalString(EObject context, UniversalString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {UnrestrictedCharacterStringType}
	 */
	protected void sequence_UnrestrictedCharacterStringType(EObject context, UnrestrictedCharacterStringType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (value=ValueRangeValue | maxValue='MAX')
	 */
	protected void sequence_UpperEndValue(EObject context, UpperEndValue semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (closed='<'? value=UpperEndValue)
	 */
	protected void sequence_UpperEndpoint(EObject context, UpperEndpoint semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type=GeneralizedTime | type=UniversalTime | type=ObjectDescriptor)
	 */
	protected void sequence_UsefulType(EObject context, UsefulType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (lowerEndpoint=LowerEndpoint upperEndpoint=UpperEndpoint)
	 */
	protected void sequence_ValueRange(EObject context, ValueRange semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.VALUE_RANGE__LOWER_ENDPOINT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.VALUE_RANGE__LOWER_ENDPOINT));
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.VALUE_RANGE__UPPER_ENDPOINT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.VALUE_RANGE__UPPER_ENDPOINT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getValueRangeAccess().getLowerEndpointLowerEndpointParserRuleCall_0_0(), semanticObject.getLowerEndpoint());
		feeder.accept(grammarAccess.getValueRangeAccess().getUpperEndpointUpperEndpointParserRuleCall_2_0(), semanticObject.getUpperEndpoint());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     number=LONG
	 */
	protected void sequence_VersionNumber(EObject context, VersionNumber semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, Asn1Package.Literals.VERSION_NUMBER__NUMBER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Asn1Package.Literals.VERSION_NUMBER__NUMBER));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getVersionNumberAccess().getNumberLONGTerminalRuleCall_0_0(), semanticObject.getNumber());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     {VideotexString}
	 */
	protected void sequence_VideotexString(EObject context, VideotexString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     {VisibleString}
	 */
	protected void sequence_VisibleString(EObject context, VisibleString semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
